home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / BORLAND TURBO / MFCINC.PAK / AFXCOLL.INL < prev    next >
Encoding:
Text File  |  1997-05-06  |  19.7 KB  |  497 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1995 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. // Inlines for AFXCOLL.H
  12.  
  13. #ifdef _AFXCOLL_INLINE
  14.  
  15. ////////////////////////////////////////////////////////////////////////////
  16.  
  17. _AFXCOLL_INLINE int CByteArray::GetSize() const
  18.     { return m_nSize; }
  19. _AFXCOLL_INLINE int CByteArray::GetUpperBound() const
  20.     { return m_nSize-1; }
  21. _AFXCOLL_INLINE void CByteArray::RemoveAll()
  22.     { SetSize(0); }
  23. _AFXCOLL_INLINE BYTE CByteArray::GetAt(int nIndex) const
  24.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  25.         return m_pData[nIndex]; }
  26. _AFXCOLL_INLINE void CByteArray::SetAt(int nIndex, BYTE newElement)
  27.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  28.         m_pData[nIndex] = newElement; }
  29. _AFXCOLL_INLINE BYTE& CByteArray::ElementAt(int nIndex)
  30.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  31.         return m_pData[nIndex]; }
  32. _AFXCOLL_INLINE const BYTE* CByteArray::GetData() const
  33.     { return (const BYTE*)m_pData; }
  34. _AFXCOLL_INLINE BYTE* CByteArray::GetData()
  35.     { return (BYTE*)m_pData; }
  36. _AFXCOLL_INLINE int CByteArray::Add(BYTE newElement)
  37.     { int nIndex = m_nSize;
  38.         SetAtGrow(nIndex, newElement);
  39.         return nIndex; }
  40. _AFXCOLL_INLINE BYTE CByteArray::operator[](int nIndex) const
  41.     { return GetAt(nIndex); }
  42. _AFXCOLL_INLINE BYTE& CByteArray::operator[](int nIndex)
  43.     { return ElementAt(nIndex); }
  44.  
  45.  
  46. ////////////////////////////////////////////////////////////////////////////
  47.  
  48. _AFXCOLL_INLINE int CWordArray::GetSize() const
  49.     { return m_nSize; }
  50. _AFXCOLL_INLINE int CWordArray::GetUpperBound() const
  51.     { return m_nSize-1; }
  52. _AFXCOLL_INLINE void CWordArray::RemoveAll()
  53.     { SetSize(0); }
  54. _AFXCOLL_INLINE WORD CWordArray::GetAt(int nIndex) const
  55.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  56.         return m_pData[nIndex]; }
  57. _AFXCOLL_INLINE void CWordArray::SetAt(int nIndex, WORD newElement)
  58.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  59.         m_pData[nIndex] = newElement; }
  60. _AFXCOLL_INLINE WORD& CWordArray::ElementAt(int nIndex)
  61.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  62.         return m_pData[nIndex]; }
  63. _AFXCOLL_INLINE const WORD* CWordArray::GetData() const
  64.     { return (const WORD*)m_pData; }
  65. _AFXCOLL_INLINE WORD* CWordArray::GetData()
  66.     { return (WORD*)m_pData; }
  67. _AFXCOLL_INLINE int CWordArray::Add(WORD newElement)
  68.     { int nIndex = m_nSize;
  69.         SetAtGrow(nIndex, newElement);
  70.         return nIndex; }
  71. _AFXCOLL_INLINE WORD CWordArray::operator[](int nIndex) const
  72.     { return GetAt(nIndex); }
  73. _AFXCOLL_INLINE WORD& CWordArray::operator[](int nIndex)
  74.     { return ElementAt(nIndex); }
  75.  
  76.  
  77. ////////////////////////////////////////////////////////////////////////////
  78.  
  79. _AFXCOLL_INLINE int CDWordArray::GetSize() const
  80.     { return m_nSize; }
  81. _AFXCOLL_INLINE int CDWordArray::GetUpperBound() const
  82.     { return m_nSize-1; }
  83. _AFXCOLL_INLINE void CDWordArray::RemoveAll()
  84.     { SetSize(0); }
  85. _AFXCOLL_INLINE DWORD CDWordArray::GetAt(int nIndex) const
  86.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  87.         return m_pData[nIndex]; }
  88. _AFXCOLL_INLINE void CDWordArray::SetAt(int nIndex, DWORD newElement)
  89.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  90.         m_pData[nIndex] = newElement; }
  91. _AFXCOLL_INLINE DWORD& CDWordArray::ElementAt(int nIndex)
  92.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  93.         return m_pData[nIndex]; }
  94. _AFXCOLL_INLINE const DWORD* CDWordArray::GetData() const
  95.     { return (const DWORD*)m_pData; }
  96. _AFXCOLL_INLINE DWORD* CDWordArray::GetData()
  97.     { return (DWORD*)m_pData; }
  98. _AFXCOLL_INLINE int CDWordArray::Add(DWORD newElement)
  99.     { int nIndex = m_nSize;
  100.         SetAtGrow(nIndex, newElement);
  101.         return nIndex; }
  102. _AFXCOLL_INLINE DWORD CDWordArray::operator[](int nIndex) const
  103.     { return GetAt(nIndex); }
  104. _AFXCOLL_INLINE DWORD& CDWordArray::operator[](int nIndex)
  105.     { return ElementAt(nIndex); }
  106.  
  107.  
  108. ////////////////////////////////////////////////////////////////////////////
  109.  
  110. _AFXCOLL_INLINE int CUIntArray::GetSize() const
  111.     { return m_nSize; }
  112. _AFXCOLL_INLINE int CUIntArray::GetUpperBound() const
  113.     { return m_nSize-1; }
  114. _AFXCOLL_INLINE void CUIntArray::RemoveAll()
  115.     { SetSize(0); }
  116. _AFXCOLL_INLINE UINT CUIntArray::GetAt(int nIndex) const
  117.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  118.         return m_pData[nIndex]; }
  119. _AFXCOLL_INLINE void CUIntArray::SetAt(int nIndex, UINT newElement)
  120.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  121.         m_pData[nIndex] = newElement; }
  122. _AFXCOLL_INLINE UINT& CUIntArray::ElementAt(int nIndex)
  123.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  124.         return m_pData[nIndex]; }
  125. _AFXCOLL_INLINE const UINT* CUIntArray::GetData() const
  126.     { return (const UINT*)m_pData; }
  127. _AFXCOLL_INLINE UINT* CUIntArray::GetData()
  128.     { return (UINT*)m_pData; }
  129. _AFXCOLL_INLINE int CUIntArray::Add(UINT newElement)
  130.     { int nIndex = m_nSize;
  131.         SetAtGrow(nIndex, newElement);
  132.         return nIndex; }
  133. _AFXCOLL_INLINE UINT CUIntArray::operator[](int nIndex) const
  134.     { return GetAt(nIndex); }
  135. _AFXCOLL_INLINE UINT& CUIntArray::operator[](int nIndex)
  136.     { return ElementAt(nIndex); }
  137.  
  138.  
  139. ////////////////////////////////////////////////////////////////////////////
  140.  
  141. _AFXCOLL_INLINE int CPtrArray::GetSize() const
  142.     { return m_nSize; }
  143. _AFXCOLL_INLINE int CPtrArray::GetUpperBound() const
  144.     { return m_nSize-1; }
  145. _AFXCOLL_INLINE void CPtrArray::RemoveAll()
  146.     { SetSize(0); }
  147. _AFXCOLL_INLINE void* CPtrArray::GetAt(int nIndex) const
  148.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  149.         return m_pData[nIndex]; }
  150. _AFXCOLL_INLINE void CPtrArray::SetAt(int nIndex, void* newElement)
  151.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  152.         m_pData[nIndex] = newElement; }
  153. _AFXCOLL_INLINE void*& CPtrArray::ElementAt(int nIndex)
  154.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  155.         return m_pData[nIndex]; }
  156. _AFXCOLL_INLINE const void** CPtrArray::GetData() const
  157.     { return (const void**)m_pData; }
  158. _AFXCOLL_INLINE void** CPtrArray::GetData()
  159.     { return (void**)m_pData; }
  160. _AFXCOLL_INLINE int CPtrArray::Add(void* newElement)
  161.     { int nIndex = m_nSize;
  162.         SetAtGrow(nIndex, newElement);
  163.         return nIndex; }
  164. _AFXCOLL_INLINE void* CPtrArray::operator[](int nIndex) const
  165.     { return GetAt(nIndex); }
  166. _AFXCOLL_INLINE void*& CPtrArray::operator[](int nIndex)
  167.     { return ElementAt(nIndex); }
  168.  
  169.  
  170. ////////////////////////////////////////////////////////////////////////////
  171.  
  172. _AFXCOLL_INLINE int CObArray::GetSize() const
  173.     { return m_nSize; }
  174. _AFXCOLL_INLINE int CObArray::GetUpperBound() const
  175.     { return m_nSize-1; }
  176. _AFXCOLL_INLINE void CObArray::RemoveAll()
  177.     { SetSize(0); }
  178. _AFXCOLL_INLINE CObject* CObArray::GetAt(int nIndex) const
  179.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  180.         return m_pData[nIndex]; }
  181. _AFXCOLL_INLINE void CObArray::SetAt(int nIndex, CObject* newElement)
  182.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  183.         m_pData[nIndex] = newElement; }
  184. _AFXCOLL_INLINE CObject*& CObArray::ElementAt(int nIndex)
  185.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  186.         return m_pData[nIndex]; }
  187. _AFXCOLL_INLINE const CObject** CObArray::GetData() const
  188.     { return (const CObject**)m_pData; }
  189. _AFXCOLL_INLINE CObject** CObArray::GetData()
  190.     { return (CObject**)m_pData; }
  191. _AFXCOLL_INLINE int CObArray::Add(CObject* newElement)
  192.     { int nIndex = m_nSize;
  193.         SetAtGrow(nIndex, newElement);
  194.         return nIndex; }
  195. _AFXCOLL_INLINE CObject* CObArray::operator[](int nIndex) const
  196.     { return GetAt(nIndex); }
  197. _AFXCOLL_INLINE CObject*& CObArray::operator[](int nIndex)
  198.     { return ElementAt(nIndex); }
  199.  
  200.  
  201. ////////////////////////////////////////////////////////////////////////////
  202.  
  203. _AFXCOLL_INLINE int CStringArray::GetSize() const
  204.     { return m_nSize; }
  205. _AFXCOLL_INLINE int CStringArray::GetUpperBound() const
  206.     { return m_nSize-1; }
  207. _AFXCOLL_INLINE void CStringArray::RemoveAll()
  208.     { SetSize(0); }
  209. _AFXCOLL_INLINE CString CStringArray::GetAt(int nIndex) const
  210.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  211.         return m_pData[nIndex]; }
  212. _AFXCOLL_INLINE void CStringArray::SetAt(int nIndex, LPCTSTR newElement)
  213.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  214.         m_pData[nIndex] = newElement; }
  215. _AFXCOLL_INLINE CString& CStringArray::ElementAt(int nIndex)
  216.     { ASSERT(nIndex >= 0 && nIndex < m_nSize);
  217.         return m_pData[nIndex]; }
  218. _AFXCOLL_INLINE const CString* CStringArray::GetData() const
  219.     { return (const CString*)m_pData; }
  220. _AFXCOLL_INLINE CString* CStringArray::GetData()
  221.     { return (CString*)m_pData; }
  222. _AFXCOLL_INLINE int CStringArray::Add(LPCTSTR newElement)
  223.     { int nIndex = m_nSize;
  224.         SetAtGrow(nIndex, newElement);
  225.         return nIndex; }
  226. _AFXCOLL_INLINE CString CStringArray::operator[](int nIndex) const
  227.     { return GetAt(nIndex); }
  228. _AFXCOLL_INLINE CString& CStringArray::operator[](int nIndex)
  229.     { return ElementAt(nIndex); }
  230.  
  231.  
  232. ////////////////////////////////////////////////////////////////////////////
  233.  
  234. _AFXCOLL_INLINE int CPtrList::GetCount() const
  235.     { return m_nCount; }
  236. _AFXCOLL_INLINE BOOL CPtrList::IsEmpty() const
  237.     { return m_nCount == 0; }
  238. _AFXCOLL_INLINE void*& CPtrList::GetHead()
  239.     { ASSERT(m_pNodeHead != NULL);
  240.         return m_pNodeHead->data; }
  241. _AFXCOLL_INLINE void* CPtrList::GetHead() const
  242.     { ASSERT(m_pNodeHead != NULL);
  243.         return m_pNodeHead->data; }
  244. _AFXCOLL_INLINE void*& CPtrList::GetTail()
  245.     { ASSERT(m_pNodeTail != NULL);
  246.         return m_pNodeTail->data; }
  247. _AFXCOLL_INLINE void* CPtrList::GetTail() const
  248.     { ASSERT(m_pNodeTail != NULL);
  249.         return m_pNodeTail->data; }
  250. _AFXCOLL_INLINE POSITION CPtrList::GetHeadPosition() const
  251.     { return (POSITION) m_pNodeHead; }
  252. _AFXCOLL_INLINE POSITION CPtrList::GetTailPosition() const
  253.     { return (POSITION) m_pNodeTail; }
  254. _AFXCOLL_INLINE void*& CPtrList::GetNext(POSITION& rPosition) // return *Position++
  255.     { CNode* pNode = (CNode*) rPosition;
  256.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  257.         rPosition = (POSITION) pNode->pNext;
  258.         return pNode->data; }
  259. _AFXCOLL_INLINE void* CPtrList::GetNext(POSITION& rPosition) const // return *Position++
  260.     { CNode* pNode = (CNode*) rPosition;
  261.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  262.         rPosition = (POSITION) pNode->pNext;
  263.         return pNode->data; }
  264. _AFXCOLL_INLINE void*& CPtrList::GetPrev(POSITION& rPosition) // return *Position--
  265.     { CNode* pNode = (CNode*) rPosition;
  266.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  267.         rPosition = (POSITION) pNode->pPrev;
  268.         return pNode->data; }
  269. _AFXCOLL_INLINE void* CPtrList::GetPrev(POSITION& rPosition) const // return *Position--
  270.     { CNode* pNode = (CNode*) rPosition;
  271.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  272.         rPosition = (POSITION) pNode->pPrev;
  273.         return pNode->data; }
  274. _AFXCOLL_INLINE void*& CPtrList::GetAt(POSITION position)
  275.     { CNode* pNode = (CNode*) position;
  276.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  277.         return pNode->data; }
  278. _AFXCOLL_INLINE void* CPtrList::GetAt(POSITION position) const
  279.     { CNode* pNode = (CNode*) position;
  280.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  281.         return pNode->data; }
  282. _AFXCOLL_INLINE void CPtrList::SetAt(POSITION pos, void* newElement)
  283.     { CNode* pNode = (CNode*) pos;
  284.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  285.         pNode->data = newElement; }
  286.  
  287.  
  288. ////////////////////////////////////////////////////////////////////////////
  289.  
  290. _AFXCOLL_INLINE int CObList::GetCount() const
  291.     { return m_nCount; }
  292. _AFXCOLL_INLINE BOOL CObList::IsEmpty() const
  293.     { return m_nCount == 0; }
  294. _AFXCOLL_INLINE CObject*& CObList::GetHead()
  295.     { ASSERT(m_pNodeHead != NULL);
  296.         return m_pNodeHead->data; }
  297. _AFXCOLL_INLINE CObject* CObList::GetHead() const
  298.     { ASSERT(m_pNodeHead != NULL);
  299.         return m_pNodeHead->data; }
  300. _AFXCOLL_INLINE CObject*& CObList::GetTail()
  301.     { ASSERT(m_pNodeTail != NULL);
  302.         return m_pNodeTail->data; }
  303. _AFXCOLL_INLINE CObject* CObList::GetTail() const
  304.     { ASSERT(m_pNodeTail != NULL);
  305.         return m_pNodeTail->data; }
  306. _AFXCOLL_INLINE POSITION CObList::GetHeadPosition() const
  307.     { return (POSITION) m_pNodeHead; }
  308. _AFXCOLL_INLINE POSITION CObList::GetTailPosition() const
  309.     { return (POSITION) m_pNodeTail; }
  310. _AFXCOLL_INLINE CObject*& CObList::GetNext(POSITION& rPosition) // return *Position++
  311.     { CNode* pNode = (CNode*) rPosition;
  312.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  313.         rPosition = (POSITION) pNode->pNext;
  314.         return pNode->data; }
  315. _AFXCOLL_INLINE CObject* CObList::GetNext(POSITION& rPosition) const // return *Position++
  316.     { CNode* pNode = (CNode*) rPosition;
  317.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  318.         rPosition = (POSITION) pNode->pNext;
  319.         return pNode->data; }
  320. _AFXCOLL_INLINE CObject*& CObList::GetPrev(POSITION& rPosition) // return *Position--
  321.     { CNode* pNode = (CNode*) rPosition;
  322.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  323.         rPosition = (POSITION) pNode->pPrev;
  324.         return pNode->data; }
  325. _AFXCOLL_INLINE CObject* CObList::GetPrev(POSITION& rPosition) const // return *Position--
  326.     { CNode* pNode = (CNode*) rPosition;
  327.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  328.         rPosition = (POSITION) pNode->pPrev;
  329.         return pNode->data; }
  330. _AFXCOLL_INLINE CObject*& CObList::GetAt(POSITION position)
  331.     { CNode* pNode = (CNode*) position;
  332.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  333.         return pNode->data; }
  334. _AFXCOLL_INLINE CObject* CObList::GetAt(POSITION position) const
  335.     { CNode* pNode = (CNode*) position;
  336.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  337.         return pNode->data; }
  338. _AFXCOLL_INLINE void CObList::SetAt(POSITION pos, CObject* newElement)
  339.     { CNode* pNode = (CNode*) pos;
  340.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  341.         pNode->data = newElement; }
  342.  
  343.  
  344. ////////////////////////////////////////////////////////////////////////////
  345.  
  346. _AFXCOLL_INLINE int CStringList::GetCount() const
  347.     { return m_nCount; }
  348. _AFXCOLL_INLINE BOOL CStringList::IsEmpty() const
  349.     { return m_nCount == 0; }
  350. _AFXCOLL_INLINE CString& CStringList::GetHead()
  351.     { ASSERT(m_pNodeHead != NULL);
  352.         return m_pNodeHead->data; }
  353. _AFXCOLL_INLINE CString CStringList::GetHead() const
  354.     { ASSERT(m_pNodeHead != NULL);
  355.         return m_pNodeHead->data; }
  356. _AFXCOLL_INLINE CString& CStringList::GetTail()
  357.     { ASSERT(m_pNodeTail != NULL);
  358.         return m_pNodeTail->data; }
  359. _AFXCOLL_INLINE CString CStringList::GetTail() const
  360.     { ASSERT(m_pNodeTail != NULL);
  361.         return m_pNodeTail->data; }
  362. _AFXCOLL_INLINE POSITION CStringList::GetHeadPosition() const
  363.     { return (POSITION) m_pNodeHead; }
  364. _AFXCOLL_INLINE POSITION CStringList::GetTailPosition() const
  365.     { return (POSITION) m_pNodeTail; }
  366. _AFXCOLL_INLINE CString& CStringList::GetNext(POSITION& rPosition) // return *Position++
  367.     { CNode* pNode = (CNode*) rPosition;
  368.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  369.         rPosition = (POSITION) pNode->pNext;
  370.         return pNode->data; }
  371. _AFXCOLL_INLINE CString CStringList::GetNext(POSITION& rPosition) const // return *Position++
  372.     { CNode* pNode = (CNode*) rPosition;
  373.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  374.         rPosition = (POSITION) pNode->pNext;
  375.         return pNode->data; }
  376. _AFXCOLL_INLINE CString& CStringList::GetPrev(POSITION& rPosition) // return *Position--
  377.     { CNode* pNode = (CNode*) rPosition;
  378.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  379.         rPosition = (POSITION) pNode->pPrev;
  380.         return pNode->data; }
  381. _AFXCOLL_INLINE CString CStringList::GetPrev(POSITION& rPosition) const // return *Position--
  382.     { CNode* pNode = (CNode*) rPosition;
  383.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  384.         rPosition = (POSITION) pNode->pPrev;
  385.         return pNode->data; }
  386. _AFXCOLL_INLINE CString& CStringList::GetAt(POSITION position)
  387.     { CNode* pNode = (CNode*) position;
  388.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  389.         return pNode->data; }
  390. _AFXCOLL_INLINE CString CStringList::GetAt(POSITION position) const
  391.     { CNode* pNode = (CNode*) position;
  392.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  393.         return pNode->data; }
  394. _AFXCOLL_INLINE void CStringList::SetAt(POSITION pos, LPCTSTR newElement)
  395.     { CNode* pNode = (CNode*) pos;
  396.         ASSERT(AfxIsValidAddress(pNode, sizeof(CNode)));
  397.         pNode->data = newElement; }
  398.  
  399.  
  400. ////////////////////////////////////////////////////////////////////////////
  401.  
  402. _AFXCOLL_INLINE int CMapWordToPtr::GetCount() const
  403.     { return m_nCount; }
  404. _AFXCOLL_INLINE BOOL CMapWordToPtr::IsEmpty() const
  405.     { return m_nCount == 0; }
  406. _AFXCOLL_INLINE void CMapWordToPtr::SetAt(WORD key, void* newValue)
  407.     { (*this)[key] = newValue; }
  408. _AFXCOLL_INLINE POSITION CMapWordToPtr::GetStartPosition() const
  409.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  410. _AFXCOLL_INLINE UINT CMapWordToPtr::GetHashTableSize() const
  411.     { return m_nHashTableSize; }
  412.  
  413.  
  414. ////////////////////////////////////////////////////////////////////////////
  415.  
  416. _AFXCOLL_INLINE int CMapPtrToWord::GetCount() const
  417.     { return m_nCount; }
  418. _AFXCOLL_INLINE BOOL CMapPtrToWord::IsEmpty() const
  419.     { return m_nCount == 0; }
  420. _AFXCOLL_INLINE void CMapPtrToWord::SetAt(void* key, WORD newValue)
  421.     { (*this)[key] = newValue; }
  422. _AFXCOLL_INLINE POSITION CMapPtrToWord::GetStartPosition() const
  423.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  424. _AFXCOLL_INLINE UINT CMapPtrToWord::GetHashTableSize() const
  425.     { return m_nHashTableSize; }
  426.  
  427.  
  428. ////////////////////////////////////////////////////////////////////////////
  429.  
  430. _AFXCOLL_INLINE int CMapPtrToPtr::GetCount() const
  431.     { return m_nCount; }
  432. _AFXCOLL_INLINE BOOL CMapPtrToPtr::IsEmpty() const
  433.     { return m_nCount == 0; }
  434. _AFXCOLL_INLINE void CMapPtrToPtr::SetAt(void* key, void* newValue)
  435.     { (*this)[key] = newValue; }
  436. _AFXCOLL_INLINE POSITION CMapPtrToPtr::GetStartPosition() const
  437.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  438. _AFXCOLL_INLINE UINT CMapPtrToPtr::GetHashTableSize() const
  439.     { return m_nHashTableSize; }
  440.  
  441.  
  442. ////////////////////////////////////////////////////////////////////////////
  443.  
  444. _AFXCOLL_INLINE int CMapWordToOb::GetCount() const
  445.     { return m_nCount; }
  446. _AFXCOLL_INLINE BOOL CMapWordToOb::IsEmpty() const
  447.     { return m_nCount == 0; }
  448. _AFXCOLL_INLINE void CMapWordToOb::SetAt(WORD key, CObject* newValue)
  449.     { (*this)[key] = newValue; }
  450. _AFXCOLL_INLINE POSITION CMapWordToOb::GetStartPosition() const
  451.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  452. _AFXCOLL_INLINE UINT CMapWordToOb::GetHashTableSize() const
  453.     { return m_nHashTableSize; }
  454.  
  455.  
  456. ////////////////////////////////////////////////////////////////////////////
  457. _AFXCOLL_INLINE int CMapStringToPtr::GetCount() const
  458.     { return m_nCount; }
  459. _AFXCOLL_INLINE BOOL CMapStringToPtr::IsEmpty() const
  460.     { return m_nCount == 0; }
  461. _AFXCOLL_INLINE void CMapStringToPtr::SetAt(LPCTSTR key, void* newValue)
  462.     { (*this)[key] = newValue; }
  463. _AFXCOLL_INLINE POSITION CMapStringToPtr::GetStartPosition() const
  464.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  465. _AFXCOLL_INLINE UINT CMapStringToPtr::GetHashTableSize() const
  466.     { return m_nHashTableSize; }
  467.  
  468.  
  469. ////////////////////////////////////////////////////////////////////////////
  470. _AFXCOLL_INLINE int CMapStringToOb::GetCount() const
  471.     { return m_nCount; }
  472. _AFXCOLL_INLINE BOOL CMapStringToOb::IsEmpty() const
  473.     { return m_nCount == 0; }
  474. _AFXCOLL_INLINE void CMapStringToOb::SetAt(LPCTSTR key, CObject* newValue)
  475.     { (*this)[key] = newValue; }
  476. _AFXCOLL_INLINE POSITION CMapStringToOb::GetStartPosition() const
  477.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  478. _AFXCOLL_INLINE UINT CMapStringToOb::GetHashTableSize() const
  479.     { return m_nHashTableSize; }
  480.  
  481.  
  482. ////////////////////////////////////////////////////////////////////////////
  483. _AFXCOLL_INLINE int CMapStringToString::GetCount() const
  484.     { return m_nCount; }
  485. _AFXCOLL_INLINE BOOL CMapStringToString::IsEmpty() const
  486.     { return m_nCount == 0; }
  487. _AFXCOLL_INLINE void CMapStringToString::SetAt(LPCTSTR key, LPCTSTR newValue)
  488.     { (*this)[key] = newValue; }
  489. _AFXCOLL_INLINE POSITION CMapStringToString::GetStartPosition() const
  490.     { return (m_nCount == 0) ? NULL : BEFORE_START_POSITION; }
  491. _AFXCOLL_INLINE UINT CMapStringToString::GetHashTableSize() const
  492.     { return m_nHashTableSize; }
  493.  
  494. /////////////////////////////////////////////////////////////////////////////
  495.  
  496. #endif //_AFXCOLL_INLINE
  497.